package com.le.tester.tip;

import java.time.LocalDateTime;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * createTime：2022/2/15 14:26
 * description：CAS核心算法
 */
public class Counter1 {
    //    public static int count = 0;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) {

        for (int i = 0; i < 3; i++) {
            //for中开启了两个线程
            long startTime = new Date().getTime();
            System.out.println("start time is " + startTime);
            new Thread(() -> {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage());
                }
                //每个线程进行自增
                for (int j = 0; j < 100; j++) {
                    //牺牲性能加上重锁
                    //既然是同步了，那么没有争夺到锁（资源）的线程，就会变成BLOCKING，直到重新争夺到锁（资源）变成RUNNABLE，此过程的切换太消耗系统的上下文切换。
//                    synchronized (Counter1.class) {
//                        count++;
//                    }
                    //或者不加重锁，使用CAS(一定要先自增，然后再减掉),确实是比之前的加上重锁比较不耗时了
                    //使用的是CAS，compare and swap;
                    //在这边，整个CAS保证的只是变量count的原子性操作。
                    //在需要保证代码块的原子性的时候，就必须使用synchronized
                    count.incrementAndGet();
                }
            }).start();
            System.out.println("result time is " + (new Date().getTime() - startTime) + "ms");
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e.getMessage());
        }
        System.out.println("count is " + count);
    }
}
